{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3",
      "language": "python"
    },
    "language_info": {
      "name": "python",
      "version": "3.7.6",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "colab": {
      "name": "24 - Whats new in txtai 4.0",
      "provenance": [],
      "collapsed_sections": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "POWZoSJR6XzK"
      },
      "source": [
        "# 💡 What's new in txtai 4.0\n",
        "\n",
        "txtai 4.0 brings a number of major feature enhancements, most importantly the capability to store full document content and text right in txtai. This notebook will cover all the changes with examples."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qa_PPKVX6XzN"
      },
      "source": [
        "# Install dependencies\n",
        "\n",
        "Install `txtai` and all dependencies."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
        "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
        "trusted": true,
        "_kg_hide-output": true,
        "id": "24q-1n5i6XzQ"
      },
      "source": [
        "%%capture\n",
        "!pip install git+https://github.com/neuml/txtai"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Content storage\n",
        "Up to now with txtai, once text was vectorized, it was no longer possible to trace back to the input text. Only document ids and vectors were stored. Results consisted of ids and scores. It was the responsibility of the developer to resolve matches with an external data store. \n",
        "\n",
        "txtai 4.0 brings a major paradigm shift. Content can now be stored alongside embeddings vectors. This opens up a number of exciting possibilities with txtai!\n",
        "\n",
        "Let's see with the classic txtai example below."
      ],
      "metadata": {
        "id": "0p3WCDniUths"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a",
        "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
        "trusted": true,
        "id": "2j_CFGDR6Xzp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "641a6b9e-dfe4-4c77-94d2-00f87c84b8f5"
      },
      "source": [
        "from txtai.embeddings import Embeddings\n",
        "\n",
        "data = [\"US tops 5 million confirmed virus cases\",\n",
        "        \"Canada's last fully intact ice shelf has suddenly collapsed, forming a Manhattan-sized iceberg\",\n",
        "        \"Beijing mobilises invasion craft along coast as Taiwan tensions escalate\",\n",
        "        \"The National Park Service warns against sacrificing slower friends in a bear attack\",\n",
        "        \"Maine man wins $1M from $25 lottery ticket\",\n",
        "        \"Make huge profits without work, earn up to $100,000 a day\"]\n",
        "\n",
        "# Create embeddings index with content enabled. The default behavior is to only store indexed vectors.\n",
        "embeddings = Embeddings({\"path\": \"sentence-transformers/nli-mpnet-base-v2\", \"content\": True, \"objects\": True})\n",
        "\n",
        "# Create an index for the list of text\n",
        "embeddings.index([(uid, text, None) for uid, text in enumerate(data)])\n",
        "\n",
        "print(\"%-20s %s\" % (\"Query\", \"Best Match\"))\n",
        "print(\"-\" * 50)\n",
        "\n",
        "# Run an embeddings search for each query\n",
        "for query in (\"feel good story\", \"climate change\", \"public health story\", \"war\", \"wildlife\", \"asia\", \"lucky\", \"dishonest junk\"):\n",
        "    # Extract text field from result\n",
        "    text = embeddings.search(query, 1)[0][\"text\"]\n",
        "\n",
        "    # Print text\n",
        "    print(\"%-20s %s\" % (query, text))"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Query                Best Match\n",
            "--------------------------------------------------\n",
            "feel good story      Maine man wins $1M from $25 lottery ticket\n",
            "climate change       Canada's last fully intact ice shelf has suddenly collapsed, forming a Manhattan-sized iceberg\n",
            "public health story  US tops 5 million confirmed virus cases\n",
            "war                  Beijing mobilises invasion craft along coast as Taiwan tensions escalate\n",
            "wildlife             The National Park Service warns against sacrificing slower friends in a bear attack\n",
            "asia                 Beijing mobilises invasion craft along coast as Taiwan tensions escalate\n",
            "lucky                Maine man wins $1M from $25 lottery ticket\n",
            "dishonest junk       Make huge profits without work, earn up to $100,000 a day\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The only change above is setting the *content* flag to True. This enables storing text and metadata content (if provided) alongside the index. Note how the text is pulled right from the query result!"
      ],
      "metadata": {
        "id": "hHGvhZm-ZTzL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Query with SQL\n",
        "\n",
        "When content is enabled, the entire dictionary will be stored and can be queried. In addition to similarity queries, txtai accepts SQL queries. This enables combined queries using both a similarity index and content stored in a database backend."
      ],
      "metadata": {
        "id": "BYWUFBUGyKyY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create an index for the list of text\n",
        "embeddings.index([(uid, {\"text\": text, \"length\": len(text)}, None) for uid, text in enumerate(data)])\n",
        "\n",
        "# Filter by score\n",
        "print(embeddings.search(\"select text, score from txtai where similar('hiking danger') and score >= 0.15\"))\n",
        "\n",
        "# Filter by metadata field 'length'\n",
        "print(embeddings.search(\"select text, length, score from txtai where similar('feel good story') and score >= 0.05 and length >= 40\"))\n",
        "\n",
        "# Run aggregate queries\n",
        "print(embeddings.search(\"select count(*), min(length), max(length), sum(length) from txtai\"))\n",
        "print()\n",
        "for x in embeddings.search(\"select count(*), min(length), max(length), sum(length), text, score from txtai group by text limit 10\"):\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aPH-dnV2ZuL1",
        "outputId": "f5e45e94-15c1-4635-8050-66c17c572dbb"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[{'text': 'The National Park Service warns against sacrificing slower friends in a bear attack', 'score': 0.3151373267173767}]\n",
            "[{'text': 'Maine man wins $1M from $25 lottery ticket', 'length': 42, 'score': 0.08329004049301147}]\n",
            "[{'count(*)': 6, 'min(length)': 39, 'max(length)': 94, 'sum(length)': 387}]\n",
            "\n",
            "{'count(*)': 1, 'min(length)': 72, 'max(length)': 72, 'sum(length)': 72, 'text': 'Beijing mobilises invasion craft along coast as Taiwan tensions escalate', 'score': None}\n",
            "{'count(*)': 1, 'min(length)': 94, 'max(length)': 94, 'sum(length)': 94, 'text': \"Canada's last fully intact ice shelf has suddenly collapsed, forming a Manhattan-sized iceberg\", 'score': None}\n",
            "{'count(*)': 1, 'min(length)': 42, 'max(length)': 42, 'sum(length)': 42, 'text': 'Maine man wins $1M from $25 lottery ticket', 'score': None}\n",
            "{'count(*)': 1, 'min(length)': 57, 'max(length)': 57, 'sum(length)': 57, 'text': 'Make huge profits without work, earn up to $100,000 a day', 'score': None}\n",
            "{'count(*)': 1, 'min(length)': 83, 'max(length)': 83, 'sum(length)': 83, 'text': 'The National Park Service warns against sacrificing slower friends in a bear attack', 'score': None}\n",
            "{'count(*)': 1, 'min(length)': 39, 'max(length)': 39, 'sum(length)': 39, 'text': 'US tops 5 million confirmed virus cases', 'score': None}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This example above adds a simple additional field, text length. Starting with txtai 4.0, the index method accepts dictionaries in the data field. \n",
        "\n",
        "Note the second query is filtering on the metadata field length along with a similarity query clause. This gives a great blend of similarity search with traditional filtering to help identify the best results."
      ],
      "metadata": {
        "id": "oH4Yd9BOlo5u"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Object storage\n",
        "\n",
        "In addition to metadata, binary content can also be associated with documents. The example below downloads an image, upserts it along with associated text into the embeddings index."
      ],
      "metadata": {
        "id": "lGmiYXyqyjtQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import urllib\n",
        "\n",
        "from IPython.display import Image\n",
        "\n",
        "# Get an image\n",
        "request = urllib.request.urlopen(\"https://raw.githubusercontent.com/neuml/txtai/master/demo.gif\")\n",
        "\n",
        "# Upsert new record having both text and an object\n",
        "embeddings.upsert([(\"txtai\", {\"text\": \"txtai executes machine-learning workflows to transform data and build AI-powered semantic search applications.\", \"object\": request.read()}, None)])\n",
        "\n",
        "# Query txtai for the most similar result to \"machine learning\" and get associated object\n",
        "result = embeddings.search(\"select object from txtai where similar('machine learning') limit 1\")[0][\"object\"]\n",
        "\n",
        "# Display image\n",
        "Image(result.getvalue(), width=600)"
      ],
      "metadata": {
        "id": "Ef4-Gd8ZtzUF",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 420
        },
        "outputId": "a633fb4d-ff88-4a8f-ca15-673e9f8dec30"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<IPython.core.display.Image object>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "image/png": {
              "width": 600
            }
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Reindex\n",
        "\n",
        "Now that content is stored, embedding indexes can be rebuilt with different configuration settings."
      ],
      "metadata": {
        "id": "PR3TzkzrjJ6x"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Print index info before (info() is also new!)\n",
        "embeddings.info()\n",
        "\n",
        "# Reindex\n",
        "embeddings.reindex({\"path\": \"sentence-transformers/paraphrase-MiniLM-L3-v2\"})\n",
        "\n",
        "print(\"------\")\n",
        "\n",
        "# Print index info after\n",
        "embeddings.info()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fAz7Jv6SjR6a",
        "outputId": "d9ffddea-bb78-4664-b0a4-ea8eccdba8f9"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{\n",
            "  \"backend\": \"faiss\",\n",
            "  \"build\": {\n",
            "    \"create\": \"2022-05-10T20:32:24Z\",\n",
            "    \"python\": \"3.7.13\",\n",
            "    \"settings\": {\n",
            "      \"components\": \"IDMap,Flat\"\n",
            "    },\n",
            "    \"system\": \"Linux (x86_64)\",\n",
            "    \"txtai\": \"4.5.0\"\n",
            "  },\n",
            "  \"content\": \"sqlite\",\n",
            "  \"dimensions\": 768,\n",
            "  \"objects\": true,\n",
            "  \"offset\": 7,\n",
            "  \"path\": \"sentence-transformers/nli-mpnet-base-v2\",\n",
            "  \"update\": \"2022-05-10T20:32:25Z\"\n",
            "}\n",
            "------\n",
            "{\n",
            "  \"backend\": \"faiss\",\n",
            "  \"build\": {\n",
            "    \"create\": \"2022-05-10T20:32:26Z\",\n",
            "    \"python\": \"3.7.13\",\n",
            "    \"settings\": {\n",
            "      \"components\": \"IDMap,Flat\"\n",
            "    },\n",
            "    \"system\": \"Linux (x86_64)\",\n",
            "    \"txtai\": \"4.5.0\"\n",
            "  },\n",
            "  \"content\": \"sqlite\",\n",
            "  \"dimensions\": 384,\n",
            "  \"objects\": true,\n",
            "  \"offset\": 7,\n",
            "  \"path\": \"sentence-transformers/paraphrase-MiniLM-L3-v2\",\n",
            "  \"update\": \"2022-05-10T20:32:26Z\"\n",
            "}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Index compression\n",
        "\n",
        "txtai normally saves index files to a directory. With 4.0, it is now possible to save compressed indexes. Indexes can be compressed to tar.gz, tar.bz2, tar.xz and zip. txtai can load compressed files and treats them as directories.\n",
        "\n",
        "Compressed indexes can be used as a backup strategy and/or as the primary storage mechanism."
      ],
      "metadata": {
        "id": "s9aLt2zF2ZW2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Save index as tar.xz\n",
        "embeddings.save(\"index.tar.xz\")\n",
        "!tar -tvJf index.tar.xz\n",
        "!echo\n",
        "!xz -l index.tar.xz\n",
        "!echo\n",
        "\n",
        "# Reload index\n",
        "embeddings.load(\"index.tar.xz\")\n",
        "\n",
        "# Test search\n",
        "embeddings.search(\"lucky guy\", 1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0oOC8ToG1pyn",
        "outputId": "7e6dd30f-a1cd-47f1-d298-abacf7b69835"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "drwx------ root/root         0 2022-05-10 20:32 ./\n",
            "-rw-r--r-- root/root       301 2022-05-10 20:32 ./config\n",
            "-rw-r--r-- root/root     77824 2022-05-10 20:32 ./documents\n",
            "-rw-r--r-- root/root     10898 2022-05-10 20:32 ./embeddings\n",
            "\n",
            "Strms  Blocks   Compressed Uncompressed  Ratio  Check   Filename\n",
            "    1       1     45.8 KiB    100.0 KiB  0.458  CRC64   index.tar.xz\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[{'id': '4',\n",
              "  'score': 0.3691234290599823,\n",
              "  'text': 'Maine man wins $1M from $25 lottery ticket'}]"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Note the compression ratio. Depending on the type of data stored, this could be quite substantial (text will compress much better than objects). "
      ],
      "metadata": {
        "id": "x5iSRKZVYfok"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# External vector models\n",
        "\n",
        "txtai supports generating vectors with [Hugging Face Transformers](https://github.com/huggingface/transformers), [PyTorch](https://github.com/pytorch/pytorch), [ONNX](https://github.com/microsoft/onnxruntime) and [Word Vector](https://github.com/neuml/staticvectors) models.\n",
        "\n",
        "This release adds support for pre-computed vectors using external models. External models may be an API, custom library and/or another way to vectorize data. This adds flexibility given the high computation cost in building embeddings vectors. Embeddings generation could be outsourced or consolidated to a group of servers with GPUs, leaving index servers to run on lower resourced machines. \n",
        "\n",
        "The example below uses the [Hugging Face Inference API](https://huggingface.co/inference-api) to build embeddings vectors. We'll load the [exact model as in the first example](#scrollTo=0p3WCDniUths) and produce the same results."
      ],
      "metadata": {
        "id": "oAISaBYVg60i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import requests\n",
        "\n",
        "def transform(inputs):\n",
        "  response = requests.post(\"https://api-inference.huggingface.co/pipeline/feature-extraction/sentence-transformers/nli-mpnet-base-v2\",\n",
        "                           json={\"inputs\": inputs})\n",
        "\n",
        "  return np.array(response.json(), dtype=np.float32)\n",
        "\n",
        "# Index data using vectors from Inference API\n",
        "embeddings = Embeddings({\"method\": \"external\", \"transform\": transform, \"content\": True})\n",
        "embeddings.index([(uid, text, None) for uid, text in enumerate(data)])\n",
        "\n",
        "print(\"%-20s %s\" % (\"Query\", \"Best Match\"))\n",
        "print(\"-\" * 50)\n",
        "\n",
        "# Run an embeddings search for each query\n",
        "for query in (\"feel good story\", \"climate change\", \"public health story\", \"war\", \"wildlife\", \"asia\", \"lucky\", \"dishonest junk\"):\n",
        "    # Extract text field from result\n",
        "    text = embeddings.search(f\"select id, text, score from txtai where similar('{query}')\", 1)[0][\"text\"]\n",
        "\n",
        "    # Print text\n",
        "    print(\"%-20s %s\" % (query, text))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d6dbB3nMk29O",
        "outputId": "fab5be50-4714-4935-8d1f-0955960d1cec"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Query                Best Match\n",
            "--------------------------------------------------\n",
            "feel good story      Maine man wins $1M from $25 lottery ticket\n",
            "climate change       Canada's last fully intact ice shelf has suddenly collapsed, forming a Manhattan-sized iceberg\n",
            "public health story  US tops 5 million confirmed virus cases\n",
            "war                  Beijing mobilises invasion craft along coast as Taiwan tensions escalate\n",
            "wildlife             The National Park Service warns against sacrificing slower friends in a bear attack\n",
            "asia                 Beijing mobilises invasion craft along coast as Taiwan tensions escalate\n",
            "lucky                Maine man wins $1M from $25 lottery ticket\n",
            "dishonest junk       Make huge profits without work, earn up to $100,000 a day\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The next example uses [spaCy](https://github.com/explosion/spaCy) to build vectors and then loads them into txtai. The vectors with this model are much faster to generate at the expense of accuracy."
      ],
      "metadata": {
        "id": "_kq_fbjd4g74"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%capture\n",
        "!pip install spacy --upgrade\n",
        "!python -m spacy download en_core_web_md"
      ],
      "metadata": {
        "id": "IIGlel3ShyGP"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import spacy\n",
        "\n",
        "# Load spacy\n",
        "nlp = spacy.load(\"en_core_web_md\")\n",
        "\n",
        "def transform(inputs):\n",
        "    return [result.vector for result in nlp.pipe(inputs)]\n",
        "\n",
        "# Index data with spacy pipeline\n",
        "embeddings = Embeddings({\"method\": \"external\", \"transform\": transform, \"content\": True})\n",
        "embeddings.index([(uid, text, None) for uid, text in enumerate(data)])\n",
        "\n",
        "# Run search\n",
        "print(embeddings.search(\"select id, text, score from txtai where similar('nature')\", 1))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nikKybxEkhjC",
        "outputId": "15dcd1cf-7068-4365-e6fe-8af29ff24b9d"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[{'id': '3', 'text': 'The National Park Service warns against sacrificing slower friends in a bear attack', 'score': 0.44850602746009827}]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aDIF3tYt6X0O"
      },
      "source": [
        "# Wrapping up\n",
        "\n",
        "This notebook gave a quick overview of txtai. txtai 4.0 is now out!\n",
        "\n",
        "See the following links for more information.\n",
        "\n",
        "- [4.0 Release on GitHub](https://github.com/neuml/txtai/releases/tag/v4.0.0)\n",
        "- [Documentation site](https://neuml.github.io/txtai)\n",
        "- [Full list of examples](https://neuml.github.io/txtai/examples/)"
      ]
    }
  ]
}
